<networkDataStructureOrJavaClass>

	/** This is similar to a Queue, but is not a queue because the things in it
	can decrease their value without telling this object.
	They must tell this object if their value increases.
	<br><br>
	A node is an Object array which contains Object arrays and/or double arrays.
	The first array in a node is always a double array, and its first index is its HEAT.
	Heat of a node is a double value the node is sorted by in its network.
	<br><br>
	When a node executes, its heat and its child nodes' heat can change.
	<br><br>
	Every time a node's heat increases, the HOTNODES for its network must be told.
	If the node was not in HOTNODES, and it increased past the THRESHOLD of the network,
	then it must be added to HOTNODES. If it was already in HOTNODES,
	then HOTNODES may have to change to remember which nodes it is hotter than.
	<br><br>
	When a node's heat decreases, nothing has to happen. It can stay in HOTNODES.
	<br><br>
	HOTNODES is an optimization that delays sorting a node until we need to know its
	sort position, which is when it possibly has the highest heat of any node in the network.
	<br><br>
	An example implemenation of this HotNodes interface may have a few lists of node
	with sizes: 4, 64, 1024, and 16384.
	That would work well for a network size 1000000 where each node has approximately 300 childs.
	It could also be done with 1 array with size equal to a power of 2,
	simulating arrays of size 1, 2, 4, 8, 16, 32 .... 16384.
	The last half of the array would be size 16384. Index 0 would not be used.
	Each list would have its own HEAT THRESHOLD,
	and the smallest would be the network's threshold.
	Either way, when a node's heat increased anywhere in the network, this would happen:
	Its heat is compared to the heat threshold of the biggest list, and added if hot enough.
	Repeat that for each smaller list. Stop when its not hot enough for a list.
	Every time the network executes, the hottest node must be found,
	which is probably in the smallest array. If its in the smallest array, use it.
	If all nodes in the smallest array, rebuild the smallest array from the second smallest.
	Recursively, if a list has no nodes with heat at least its threshold,
	rebuild from the next bigger array.
	<br><br>
	All that is complicated so it is done in this interface
	instead of being a requirement of how networks work.
	Nodes are Object arrays, but networks can be instances of custom Java classes.
	*/

	/** a node is an Object array.
	Returns the node with maximum double value at ((double[])node[0])[0].
	*/
	public Object[] hottestNode();
	
	/** call this every time a node's heat increases
	and its current heat is possibly at least heatThreshold().
	*/ 
	public void nodeHeating(Object node[]);
	
	/** All nodes in the network are colder than this,
	and any node in this can be any temperature.
	*/
	public double heatThreshold();

	/** A network has 1 shared array that is always full, is never replaced,
	and is shared between all nodes of that network, viewed as if they were
	adjacent to each individual node's arrays. A node is an
	Object array (always the same size in the same network) of arrays and/or Integers
	viewed as arrays of that Integer size but nothing reads/writes to indexs in them.
	<br><br>
	Usually this Object array (and a node which is also an Object array) size
	is small. For example, a node in a neural network might have 3 arrays:
	an Object array of child nodes, a double array (same size) of weights,
	and a size-1 double array containing the activation level of the node.
	*/
	public Object[] sharedArrays();
	
	/** In a standard syntax, defines array class types and size requirements,
	and all other algorithms that define this network.
	Does not include the specific nodes or data of this network.
	*/
	public String netCode();
	
	/** TODO: What data structure to store all nodes in, and how to get all nodes?
	This may be an expensive operation??? TODO: verify it is not expensive.
	Is this Collection ok?
	*/
	public Collection getNodes();
	
	//TODO: Should node[0][0] be heat and node[0][1] be lastSortedHeat,
	//and have only 1 group of HOTNODES, and it uses lastSortedHeat?
	//Or should lastSortedHeat be part of a HotNodes object and not the node?
	
	
	/*
	How should nodes be stored?
	
	Relevant questions:
	Do I ever need to quickly check if a network contains a node?
	Do I ever need nodes to have index in the network?
	Do I ever need to quickly add a node to a network?
	*/	

</networkDataStructureOrJavaClass>